# Python 数据结构之集合（Set）

# 集合（Set）是由一组无序且唯一的元素组成的集合。集合中的元素可以是数字、字符串、元组或者其他类型。
# 集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。
# 可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。


# 创建集合的语法
# s = {element1, element2,..., elementN}
# s = set(iterable)


# 集合的内置方法
# add(element) 向集合中添加一个元素
# remove(element) 从集合中删除一个元素
# update(iterable) 更新集合，将 iterable 中的元素添加到集合中
# intersection(iterable) 返回两个集合的交集
# intersection_update(iterable) 更新当前集合的交集
# union(iterable) 返回两个集合的并集
# clear() 清空集合
# copy() 返回当前集合的浅拷贝
# pop() 随机删除集合中的一个元素，并返回该元素
# difference(iterable) 返回两个集合的差集
# difference_update(iterable) 更新当前集合的差集
# discard(element) 从集合中删除一个元素，如果该元素不存在，则不报错
# symmetric_difference_update(iterable) 更新当前集合的对称差集
# symmetric_difference(iterable) 返回两个集合的对称差集
# issubset(iterable) 判断当前集合是否是 iterable 的子集
# issuperset(iterable) 判断当前集合是否是 iterable 的超集
# isdisjoint(iterable) 判断当前集合是否和 iterable 有交集



# 创建集合
# 创建一个空集合
s1 = set()
print(s1)  # 输出：set()


# 创建一个有元素的集合
s2 = {1, 2, 3, 4, 5}
print("原始集合:", s2)  # 输出：{1, 2, 3, 4, 5}


# 创建一个字符串集合
s3 = set("fuck you")
print("字符串集合:", s3)  # 输出：{'f', 'u', 'c', 'k', ' ', 'y', 'o', 'u'}


# 集合基本操作
# 1. 元素的添加
s2.add(6)
print("添加后的集合：", s2)  # 输出：{1, 2, 3, 4, 5, 6}

# 2. 元素的删除
s2.remove(5)
print("删除后的集合：", s2)  # 输出：{1, 2, 3, 4, 6}

# 3. 集合的合并
s4 = {4, 5, 6, 7, 8}
s2.update(s4)
print("合并后的集合：", s2)  # 输出：{1, 2, 3, 4, 5, 6, 7, 8}

# 4. 集合的交集
s5 = {1, 2, 3}
s6 = {2, 3, 4}
s7 = s5.intersection(s6)
print("交集：", s7)  # 输出：{2, 3}

# 5. 集合的并集
s8 = s5.union(s6)
print("并集：", s8)  # 输出：{1, 2, 3, 4}


# 集合的其他操作
# 1. 集合的大小
print("集合的长度", len(s8))  # 输出：4

# 2. 集合的遍历
for i in s8:
    print(i)  # 输出：1 2 3 4


# 集合的应用
# 1. 去重
s9 = {1, 2, 3, 2, 1, 4, 5, 4, 6, 7, 8, 7, 9}
s10 = set(s9)
print("去重后的集合：", s10)  # 输出：{1, 2, 3, 4, 5, 6, 7, 8, 9}

# 2. 集合的元素判断
if 2 in s10:      # 判断元素是否存在于集合中
    print("存在")
else:
    print("不存在")

# 3. 集合的排序
s11 = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}
s12 = sorted(s11)
print("排序后的集合：", s12)  # 输出：[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]


# 集合的其他方法
# 1. 集合的浅拷贝
s13 = s10.copy()
print("浅拷贝后的集合：", s13)  # 输出：{1, 2, 3, 4, 5, 6, 7, 8, 9}

# 2. 集合的随机删除
s14 = {1, 2, 3, 4, 5}
s14.pop()
print("随机删除后的集合：", s14)  # 输出：{1, 2, 3, 4}

# 集合的运算
# 1. 集合的差集
s15 = {1, 2, 3, 4, 5}
s16 = {4, 5, 6, 7, 8}
s17 = s15.difference(s16)
print("差集：", s17)  # 输出：{1, 2, 3}

# 2. 集合的对称差集 返回两个集合中不重复的元素集合。
s18 = {1, 2, 3, 4, 5}
s19 = {4, 5, 6, 7, 8}
s20 = s15.symmetric_difference(s16)
print("对称差集：", s20)  # 输出：{1, 2, 3, 6, 7, 8}

# 集合的判断
# 1. 判断是否为子集
s21 = {1, 2, 3}
s22 = {1, 2, 3, 4, 5}
if s21.issubset(s22):
    print("s21 是 s22 的子集")
else:
    print("s21 不是 s22 的子集")

# 2. 判断是否为超集
s23 = {1, 2, 3, 4, 5}
s24 = {1, 2, 3}
if s23.issuperset(s24):
    print("s23 是 s24 的超集")
else:
    print("s23 不是 s24 的超集")

# 3. 判断是否有交集
s25 = {1, 2, 3}
s26 = {2, 3, 4}
if s25.isdisjoint(s26):
    print("s25 和 s26 没有交集")
else:
    print("s25 和 s26 有交集")


# difference_update() 方法
# 该方法用于更新当前集合的差集，即从当前集合中删除 iterable 中的元素。
s27 = {1, 2, 3, 4, 5}
s28 = {4, 5, 6, 7, 8}
s27.difference_update(s28)
print("difference_update() 后的集合：", s27)  # 输出：{1, 2, 3}


# symmetric_difference_update() 方法
# 该方法用于更新当前集合的对称差集，即从当前集合中删除 iterable 中的元素，并将剩余的元素添加到当前集合中。
s29 = {1, 2, 3, 4, 5}
s30 = {4, 5, 6, 7, 8}
s29.symmetric_difference_update(s30)
print("symmetric_difference_update() 后的集合：", s29)  # 输出：{1, 2, 3, 6, 7, 8}


# discard() 方法
# 该方法用于从集合中删除一个元素，如果该元素不存在，则不报错。
s31 = {1, 2, 3, 4, 5}
s31.discard(8)
s31.remove(8)  # 等价于 discard() 方法, 但会报错
print("discard() 后的集合：", s31)  # 输出：{1, 2, 4, 5}